package com.ruoyi.yys.service.impl;

import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.StrUtil;
import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.yys.common.enums.DatabaseType;
import com.ruoyi.yys.domain.ImportExportTemplate;
import com.ruoyi.yys.domain.JdbcConfig;
import com.ruoyi.yys.mapper.JdbcConfigMapper;
import com.ruoyi.yys.service.IImportExportTemplateService;
import com.ruoyi.yys.service.IJdbcConfigService;
import com.ruoyi.yys.util.XyUtils;
import com.ruoyi.yys.util.dbUtil.JdbcDbUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.sql.SQLException;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 数据库连接配置Service业务层处理
 * 
 * @author xinyin
 * @date 2022-12-07
 */
@Service
@RequiredArgsConstructor
public class JdbcConfigServiceImpl implements IJdbcConfigService 
{
    private final JdbcConfigMapper jdbcConfigMapper;

    private final IImportExportTemplateService templateService;

    /**
     * 查询数据库连接配置
     * 
     * @param id 数据库连接配置主键
     * @return 数据库连接配置
     */
    @Override
    public JdbcConfig selectJdbcConfigById(String id)
    {
        return jdbcConfigMapper.selectJdbcConfigById(id);
    }

    /**
     * 查询数据库连接配置列表
     * 
     * @param jdbcConfig 数据库连接配置
     * @return 数据库连接配置
     */
    @Override
    public List<JdbcConfig> selectJdbcConfigList(JdbcConfig jdbcConfig)
    {
        return jdbcConfigMapper.selectJdbcConfigList(jdbcConfig);
    }

    /**
     * 新增数据库连接配置
     * 
     * @param jdbcConfig 数据库连接配置
     * @return 结果
     */
    @Override
    public int insertJdbcConfig(JdbcConfig jdbcConfig)
    {
        jdbcConfig.setId(XyUtils.getId32()).setCreateBy(SecurityUtils.getUsername());
        jdbcConfig.setCreateTime(DateUtils.getNowDate());
        return jdbcConfigMapper.insertJdbcConfig(jdbcConfig);
    }

    /**
     * 修改数据库连接配置
     * 
     * @param jdbcConfig 数据库连接配置
     * @return 结果
     */
    @Override
    public int updateJdbcConfig(JdbcConfig jdbcConfig)
    {
        jdbcConfig.setUpdateTime(DateUtils.getNowDate());
        jdbcConfig.setUpdateBy(SecurityUtils.getUsername());
        return jdbcConfigMapper.updateJdbcConfig(jdbcConfig);
    }

    /**
     * 批量删除数据库连接配置
     * 
     * @param ids 需要删除的数据库连接配置主键
     * @return 结果
     */
    @Override
    public int deleteJdbcConfigByIds(String[] ids)
    {
        return jdbcConfigMapper.deleteJdbcConfigByIds(ids);
    }

    /**
     * 删除数据库连接配置信息
     * 
     * @param id 数据库连接配置主键
     * @return 结果
     */
    @Override
    public int deleteJdbcConfigById(String id)
    {
        return jdbcConfigMapper.deleteJdbcConfigById(id);
    }

    /**
     * 根据模板id获取数据库连接
     *
     * @param templateId 模板id
     * @return {@link JdbcConfig}
     */
    @Override
    public JdbcConfig getJdbcByTemplateId(Long templateId) {
        ImportExportTemplate template = templateService.selectImportExportTemplateById(templateId);
        return jdbcConfigMapper.selectJdbcConfigById(template.getJdbcConfigId());
    }

    /**
     * 数据源列表
     *
     * @return {@link Object}
     */
    @Override
    public List<Dict> listDatasource() {
        List<JdbcConfig> jdbcConfigs = selectJdbcConfigList(new JdbcConfig());
        List<Dict> res = jdbcConfigs.stream().map(e -> {
            String id = e.getId();
            String databaseName = e.getDatabaseName();
            String remark = e.getRemark();
            if (StrUtil.isNotBlank(remark)) {
                databaseName = StrUtil.format("{}({})", databaseName, remark);
            }
            return Dict.create().set("label", databaseName).set("value", id);
        }).collect(Collectors.toList());
        return res;
    }

    /**
     * 根据数据源获取该库的所有表
     *
     * @param databaseId 数据库id
     * @return {@link List}<{@link Dict}>
     */
    @Override
    public List<Dict> listTables(String databaseId) {
        //获取数据源
        JdbcConfig jdbcConfig = selectJdbcConfigById(databaseId);
        Db db = JdbcDbUtil.getDatabase(jdbcConfig);
        String type = jdbcConfig.getType();
        String sql = "";
        //根据数据源获取查询的sql语句
        if(DatabaseType.MYSQL.getType().toLowerCase().equals(type)){
            sql = StrUtil.format("SELECT a.TABLE_NAME,a.TABLE_COMMENT FROM information_schema.TABLES a WHERE TABLE_SCHEMA='{}'",jdbcConfig.getDatabaseName());
        }else if(DatabaseType.SQLSERVER.getType().toLowerCase().equals(type)){
            sql = "SELECT name TABLE_NAME,* FROM sys.tables ORDER BY name";
        }
        try {
            List<Entity> datas = db.query(sql);
            return datas.stream().map(e->Dict.create().set("label", e.getStr("TABLE_NAME")).set("value", e.getStr("TABLE_NAME"))).collect(Collectors.toList());
        } catch (SQLException e) {
            throw new ServiceException("获取数据出错：" + e.getMessage());
        }
    }
}
